A Timed IO monad

Programming with explicit timing information is often tedious and error prone. This is especially visible in music programming where, when played, the specified durations of notes and rests must be shortened in order to compensate the actual duration of all surrounding processing. In this paper, we develop the notion of timed extension of a monad that aims at relieving programmers from such a burden. We show how, under simple conditions, such extensions can be built, and how useful features of monad programming such as asynchronous concurrency with promises or data-flow programming with monadic streams can be uniformly lifted to the resulting timed programming framework. Even though presented and developed in the abstract, the notion of timed extension of a monad is nevertheless illustrated by two concrete instances: a default timed IO monad where programmers specify durations in mi-croseconds, and a musically timed IO monad, where programmers specify durations in number of beats, the underlying tempo, that is, the speed of the music in beats per minute, possibly changed whenever needed

No more, no less - A formal model for serverless computing

Serverless computing, also known as Functions-as-a-Service, is a recent paradigm aimed at simplifying the programming of cloud applications. The idea is that developers design applications in terms of functions, which are then deployed on a cloud infrastructure. The infrastructure takes care of executing the functions whenever requested by remote clients, dealing automatically with distribution and scaling with respect to inbound traffic. While vendors already support a variety of programming languages for serverless computing (e.g. Go, Java, Javascript, Python), as far as we know there is no reference model yet to formally reason on this paradigm. In this paper, we propose the first formal programming model for serverless computing, which combines ideas from both the $\lambda$-calculus (for functions) and the $\pi$-calculus (for communication). To illustrate our proposal, we model a real-world serverless system. Thanks to our model, we are also able to capture and pinpoint the limitations of current vendor technologies, proposing possible amendments

No More, No Less - A Formal Model for Serverless Computing

Part 3: Exploring New FrontiersInternational audienceServerless computing, also known as Functions-as-a-Service, is a recent paradigm aimed at simplifying the programming of cloud applications. The idea is that developers design applications in terms of functions, which are then deployed on a cloud infrastructure. The infrastructure takes care of executing the functions whenever requested by remote clients, dealing automatically with distribution and scaling with respect to inbound traffic.While vendors already support a variety of programming languages for serverless computing (e.g. Go, Java, Javascript, Python), as far as we know there is no reference model yet to formally reason on this paradigm. In this paper, we propose the first core formal programming model for serverless computing, which combines ideas from both the lambda-calculus (for functions) and the pi-calculus (for communication). To illustrate our proposal, we model a real-world serverless system. Thanks to our model, we capture limitations of current vendors and formalise possible amendments

Activation of Toll-Like Receptor 3 Impairs the Dengue Virus Serotype 2 Replication through Induction of IFN-β in Cultured Hepatoma Cells

Toll-like receptors (TLRs) play an important role in innate immunity against invading pathogens. Although TLR signaling has been indicated to protect cells from infection of several viruses, the role of TLRs in Dengue virus (DENV) replication is still unclear. In the present study, we examined the replication of DENV serotype 2 (DENV2) by challenging hepatoma cells HepG2 with different TLR ligands. Activation of TLR3 showed an antiviral effect, while pretreatment of other TLR ligands (including TLR1/2, TLR2/6, TLR4, TLR5 or TLR7/8) did not show a significant effect. TLR3 ligand poly(I∶C) treatment prior to viral infection or simultaneously, but not post-treatment, significantly down-regulated virus replication. Pretreatment with poly(I∶C) reduced viral mRNA expression and viral staining positive cells, accompanying an induction of the type I interferon (IFN-β) and type III IFN (IL-28A/B). Intriguingly, neutralization of IFN-β alone successfully restored the poly(I∶C)-inhibited replication of DENV2. The poly(I∶C)-mediated effects, including IFN induction and DENV2 suppression, were significantly reversed by IKK inhibitor, further suggesting that IFN-β is the dominant factor involved in the poly(I∶C) mediated antiviral effect. Our study presented the first evidence to show that activation of TLR3 is effective in blocking DENV2 replication via IFN-β, providing an experimental clue that poly(I∶C) may be a promising immunomodulatory agent against DENV infection and might be applicable for clinical prevention

Active Objects for Coordinating BSP Computations (Short Paper)

International audienceAmong the programming models for parallel and distributed computing, one can identify two important families. The programming models adapted to data-parallelism, where a set of coordinated processes perform a computation by splitting the input data; and coordination languages able to express complex coordination patterns and rich interactions between processing entities. This article takes two successful programming models belonging to the two categories and puts them together into an effective programming model. More precisely, we investigate the use of active objects to coordinate BSP processes. We choose two paradigms that both enforce the absence of data-races, one of the major sources of error in parallel programming. This article explains why we believe such a model is interesting and provides a formal semantics integrating the notions of the two programming paradigms in a coherent and effective manner

Forward to a Promising Future

In many actor-based programming models, asynchronous method calls communicate their results using futures, where the fulfilment occurs under-the-hood. Promises play a similar role to futures, except that they must be explicitly created and explicitly fulfilled; this makes promises more flexible than futures, though promises lack fulfilment guarantees: they can be fulfilled once, multiple times or not at all. Unfortunately, futures are too rigid to exploit many available concurrent and parallel patterns. For instance, many computations block on a future to get its result only to return that result immediately (to fulfil their own future). To make futures more flexible, we explore a construct, forward, that delegates the responsibility for fulfilling the current implicit future to another computation. Forward reduces synchronisation and gives futures promise-like capabilities. This paper presents a formalisation of the forward construct, defined in a high-level source language, and a compilation strategy from the high-level language to a low-level, promised-based target language. The translation is shown to preserve semantics. Based on this foundation, we describe the implementation of forward in the parallel, actor-based language Encore, which compiles to C

Forward to a Promising Future

International audienceIn many actor-based programming models, asynchronous method calls communicate their results using futures, where the fulfilment occurs under-the-hood. Promises play a similar role to futures, except that they must be explicitly created and explicitly fulfilled; this makes promises more flexible than futures, though promises lack fulfilment guarantees: they can be fulfilled once, multiple times or not at all. Unfortunately, futures are too rigid to exploit many available concurrent and parallel patterns. For instance, many computations block on a future to get its result only to return that result immediately (to fulfil their own future). To make futures more flexible, we explore a construct, forward, that delegates the responsibility for fulfilling the current implicit future to another computation. Forward reduces synchronisation and gives futures promise-like capabilities. This paper presents a formalisation of the forward construct, defined in a high-level source language, and a compilation strategy from the high-level language to a low-level, promised-based target language. The translation is shown to preserve semantics. Based on this foundation, we describe the implementation of forward in the parallel, actor-based language Encore, which compiles to C